package com.minecolonies.coremod.generation.defaults;

import com.minecolonies.api.blocks.ModBlocks;
import com.minecolonies.api.items.ModItems;
import com.minecolonies.api.items.ModTags;
import com.minecolonies.api.util.constant.TagConstants;
import com.minecolonies.coremod.generation.CompostRecipeBuilder;
import com.minecolonies.coremod.recipes.FoodIngredient;
import com.minecolonies.coremod.recipes.PlantIngredient;
import net.minecraft.advancements.critereon.InventoryChangeTrigger;
import net.minecraft.advancements.critereon.ItemPredicate;
import net.minecraft.data.DataGenerator;
import net.minecraft.data.recipes.*;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.tags.ItemTags;
import net.minecraft.tags.Tag;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.Items;
import net.minecraft.world.item.crafting.Ingredient;
import net.minecraft.world.item.crafting.RecipeSerializer;
import net.minecraft.world.item.crafting.SimpleCookingSerializer;
import net.minecraft.world.level.ItemLike;
import net.minecraftforge.common.Tags;
import org.jetbrains.annotations.NotNull;

import java.util.function.Consumer;

import static com.ldtteam.structurize.items.ModItems.buildTool;
import static com.ldtteam.structurize.items.ModItems.shapeTool;
import static com.minecolonies.api.util.constant.Constants.MOD_ID;

/**
 * Datagen for standard crafting recipes
 */
public class DefaultRecipeProvider extends RecipeProvider
{
    public DefaultRecipeProvider(@NotNull final DataGenerator dataGenerator)
    {
        super(dataGenerator);
    }

    @NotNull
    @Override
    public String getName()
    {
        return "DefaultVanillaRecipeProvider";
    }

    @Override
    protected void buildCraftingRecipes(@NotNull final Consumer<FinishedRecipe> consumer)
    {
        buildHutRecipes(consumer);
        buildOtherBlocks(consumer);
        buildOtherItems(consumer);

        buildFood(consumer, "", RecipeSerializer.SMELTING_RECIPE, 200);
        buildFood(consumer, "smoking", RecipeSerializer.SMOKING_RECIPE, 100);
        buildFood(consumer, "campfire_cooking", RecipeSerializer.CAMPFIRE_COOKING_RECIPE, 600);

        CompostRecipeBuilder.strength(2)
                .input(new FoodIngredient.Builder().maxSaturation(0.5f).build())
                .input(Ingredient.of(ModTags.compostables_poor))
                .save(consumer, TagConstants.COMPOSTABLES_POOR);
        CompostRecipeBuilder.strength(4)
                .input(new FoodIngredient.Builder().minSaturation(0.5f).maxSaturation(1.0f).build())
                .input(PlantIngredient.getInstance())
                .input(Ingredient.of(ModTags.compostables))
                .save(consumer, TagConstants.COMPOSTABLES);
        CompostRecipeBuilder.strength(8)
                .input(new FoodIngredient.Builder().minSaturation(1.0f).build())
                .input(Ingredient.of(ModTags.compostables_rich))
                .save(consumer, TagConstants.COMPOSTABLES_RICH);
    }

    private void buildHutRecipes(@NotNull final Consumer<FinishedRecipe> consumer)
    {
        registerHutRecipe3(consumer, ModBlocks.blockHutArchery, Items.BOW);
        registerHutRecipe1(consumer, ModBlocks.blockHutBaker, Items.WHEAT);
        registerHutRecipe1(consumer, ModBlocks.blockHutBarracks, Items.IRON_BLOCK);
        registerHutRecipe1(consumer, ModBlocks.blockHutBeekeeper, Items.BEEHIVE);
        registerHutRecipe3(consumer, ModBlocks.blockHutBlacksmith, Items.IRON_INGOT);
        registerHutRecipe1(consumer, ModBlocks.blockHutBuilder, ItemTags.WOODEN_DOORS);
        registerHutRecipe1(consumer, ModBlocks.blockHutChickenHerder, Items.EGG);
        registerHutRecipe1(consumer, ModBlocks.blockHutHome, Items.TORCH);
        registerHutRecipe3(consumer, ModBlocks.blockHutCombatAcademy, Items.IRON_SWORD);
        registerHutRecipe1(consumer, ModBlocks.blockHutComposter, ModBlocks.blockBarrel);
        registerHutRecipe1(consumer, ModBlocks.blockHutConcreteMixer, Items.WHITE_CONCRETE_POWDER);
        registerHutRecipe1(consumer, ModBlocks.blockHutCook, Items.APPLE);
        registerHutRecipe1(consumer, ModBlocks.blockHutCowboy, Items.BEEF);
        registerHutRecipe1(consumer, ModBlocks.blockHutDeliveryman, Items.LEATHER_BOOTS);
        registerHutRecipe1x2(consumer, ModBlocks.blockHutDeliveryman, Items.IRON_BOOTS, "iron");
        registerHutRecipe1(consumer, ModBlocks.blockHutDyer, Items.RED_DYE);
        registerHutRecipe1(consumer, ModBlocks.blockHutEnchanter, Items.ENCHANTING_TABLE);
        registerHutRecipe1(consumer, ModBlocks.blockHutFarmer, Items.WOODEN_HOE);
        registerHutRecipe1x2(consumer, ModBlocks.blockHutFarmer, Items.STONE_HOE, "stone");
        registerHutRecipe1(consumer, ModBlocks.blockHutFisherman, Items.FISHING_ROD);
        registerHutRecipe1(consumer, ModBlocks.blockHutFletcher, Items.STRING);
        registerHutRecipe1(consumer, ModBlocks.blockHutFlorist, Items.POPPY);
        registerHutRecipe1(consumer, ModBlocks.blockHutGlassblower, Items.GLASS);
        registerHutRecipe1x2(consumer, ModBlocks.blockHutGuardTower, Items.BOW, "");
        registerHutRecipe1(consumer, ModBlocks.blockHutHospital, Items.CARROT);
        registerHutRecipe1(consumer, ModBlocks.blockHutLibrary, Items.BOOK);
        registerHutRecipe1(consumer, ModBlocks.blockHutLumberjack, Items.WOODEN_AXE);
        registerHutRecipe1x2(consumer, ModBlocks.blockHutLumberjack, Items.STONE_AXE, "stone");
        registerHutRecipe1(consumer, ModBlocks.blockHutMechanic, Items.REDSTONE_BLOCK);
        registerHutRecipe1(consumer, ModBlocks.blockHutMiner, Items.WOODEN_PICKAXE);
        registerHutRecipe1x2(consumer, ModBlocks.blockHutMiner, Items.STONE_PICKAXE, "stone");
        registerHutRecipe1(consumer, ModBlocks.blockHutMysticalSite, Items.DIAMOND);
        registerHutRecipe1(consumer, ModBlocks.blockHutPlantation, Items.CACTUS);
        registerHutRecipe1(consumer, ModBlocks.blockHutRabbitHutch, Items.RABBIT);
        registerHutRecipe3(consumer, ModBlocks.blockHutSawmill, Items.WOODEN_AXE);
        registerHutRecipe1(consumer, ModBlocks.blockHutShepherd, Items.SHEARS);
        registerHutRecipe3(consumer, ModBlocks.blockHutSifter, Items.STRING);
        registerHutRecipe1(consumer, ModBlocks.blockHutSmeltery, Items.IRON_INGOT);
        registerHutRecipe3(consumer, ModBlocks.blockHutStonemason, Items.STONE_BRICKS);
        registerHutRecipe1(consumer, ModBlocks.blockHutSwineHerder, Items.PORKCHOP);
        registerHutRecipe1(consumer, ModBlocks.blockHutTavern, Items.BARREL);
        registerHutRecipe1(consumer, ModBlocks.blockHutTownHall, buildTool.get());
        registerHutRecipe1(consumer, ModBlocks.blockHutWareHouse, Tags.Items.CHESTS);

        ShapedRecipeBuilder.shaped(ModBlocks.blockHutCrusher)
                .pattern("XTX")
                .pattern("CBC")
                .pattern("XXX")
                .define('X', ItemTags.PLANKS)
                .define('C', Items.COBBLESTONE)
                .define('B', Items.IRON_INGOT)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), Items.IRON_INGOT))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockHutGraveyard)
                .pattern("XTX")
                .pattern("XBX")
                .pattern("XXX")
                .define('X', Items.STONE)
                .define('B', Items.BONE)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), Items.BONE))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockHutSchool)
                .pattern("XTX")
                .pattern("XBX")
                .pattern("XBX")
                .define('X', ItemTags.PLANKS)
                .define('B', Items.FEATHER)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), Items.FEATHER))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockHutUniversity)
                .pattern("XTX")
                .pattern("XBX")
                .pattern("XBX")
                .define('X', ItemTags.PLANKS)
                .define('B', Items.BOOK)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), Items.BOOK))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockHutStoneSmeltery)
                .pattern("XTX")
                .pattern("AFA")
                .pattern("XXX")
                .define('X', ItemTags.PLANKS)
                .define('A', Items.STONE_BRICKS)
                .define('F', Items.FURNACE)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), Items.STONE_BRICKS))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockScarecrow)
                .pattern(" H ")
                .pattern("SLS")
                .pattern(" S ")
                .define('L', Items.LEATHER)
                .define('S', Items.STICK)
                .define('H', Ingredient.of(Items.HAY_BLOCK, Items.PUMPKIN))
                .unlockedBy("has_items", hasAllOf(buildTool.get(), ModBlocks.blockHutFarmer))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockSimpleQuarry)
                .pattern("XTX")
                .pattern("XDX")
                .pattern("XBX")
                .define('X', ItemTags.PLANKS)
                .define('D', Items.IRON_PICKAXE)
                .define('B', Items.BARREL)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), ModBlocks.blockHutMiner))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockMediumQuarry)
                .pattern("XTX")
                .pattern("XDX")
                .pattern("XBX")
                .define('X', ItemTags.PLANKS)
                .define('D', Items.DIAMOND_PICKAXE)
                .define('B', Items.BARREL)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), ModBlocks.blockHutMiner))
                .save(consumer);

//        ShapedRecipeBuilder.shaped(ModBlocks.blockLargeQuarry)
//                .pattern("XTX")
//                .pattern("XDX")
//                .pattern("XBX")
//                .define('X', ItemTags.PLANKS)
//                .define('D', Items.NETHERITE_PICKAXE)
//                .define('B', Items.BARREL)
//                .define('T', buildTool.get())
//                .unlockedBy("has_items", hasAllOf(buildTool.get(), ModBlocks.blockHutMiner))
//                .save(consumer);
    }

    private static InventoryChangeTrigger.TriggerInstance hasAllOf(ItemLike... items)
    {
        return InventoryChangeTrigger.TriggerInstance.hasItems(items);
    }

    private static InventoryChangeTrigger.TriggerInstance hasAllOf(ItemPredicate... predicates)
    {
        return InventoryChangeTrigger.TriggerInstance.hasItems(predicates);
    }

    private static ResourceLocation append(@NotNull final ResourceLocation base,
                                           @NotNull final String text1,
                                           @NotNull final String text2)
    {
        if (text2.isEmpty()) return base;
        return new ResourceLocation(MOD_ID, base.getPath() + text1 + text2);
    }

    private static ResourceLocation append(@NotNull final ItemLike item,
                                           @NotNull final String text)
    {
        return append(item.asItem().getRegistryName(), "", text);
    }

    private static void registerHutRecipe1(@NotNull final Consumer<FinishedRecipe> consumer,
                                           @NotNull final ItemLike output,
                                           @NotNull final ItemLike input)
    {
        ShapedRecipeBuilder.shaped(output)
                .pattern("XTX")
                .pattern("XBX")
                .pattern("XXX")
                .define('X', ItemTags.PLANKS)
                .define('B', input)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), input))
                .save(consumer);
    }

    private static void registerHutRecipe1(@NotNull final Consumer<FinishedRecipe> consumer,
                                           @NotNull final ItemLike output,
                                           @NotNull final Tag<Item> input)
    {
        ShapedRecipeBuilder.shaped(output)
                .pattern("XTX")
                .pattern("XBX")
                .pattern("XXX")
                .define('X', ItemTags.PLANKS)
                .define('B', input)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(
                        ItemPredicate.Builder.item().of(buildTool.get()).build(),
                        ItemPredicate.Builder.item().of(input).build()))
                .save(consumer);
    }

    private static void registerHutRecipe1x2(@NotNull final Consumer<FinishedRecipe> consumer,
                                             @NotNull final ItemLike output,
                                             @NotNull final ItemLike input,
                                             @NotNull final String name)
    {
        ShapedRecipeBuilder.shaped(output, 2)
                .pattern("XTX")
                .pattern("XBX")
                .pattern("XXX")
                .define('X', ItemTags.PLANKS)
                .define('B', input)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), input))
                .save(consumer, append(output, name));
    }

    private static void registerHutRecipe3(@NotNull final Consumer<FinishedRecipe> consumer,
                                           @NotNull final ItemLike output,
                                           @NotNull final ItemLike input)
    {
        ShapedRecipeBuilder.shaped(output)
                .pattern("XTX")
                .pattern("BBB")
                .pattern("XXX")
                .define('X', ItemTags.PLANKS)
                .define('B', input)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), input))
                .save(consumer);
    }

    private void buildOtherBlocks(@NotNull final Consumer<FinishedRecipe> consumer)
    {
        ShapedRecipeBuilder.shaped(ModBlocks.blockBarrel)
                .pattern("WTW")
                .pattern("WGW")
                .pattern("WSW")
                .define('W', ItemTags.PLANKS)
                .define('S', Items.IRON_INGOT)
                .define('G', Items.DIRT)
                .define('T', buildTool.get())
                .unlockedBy("has_items", hasAllOf(buildTool.get(), Items.IRON_INGOT))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockCompostedDirt)
                .pattern("XXX")
                .pattern("XPX")
                .pattern("XXX")
                .define('X', Items.DIRT)
                .define('P', ModItems.compost)
                .unlockedBy("has_compost", has(ModItems.compost))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockConstructionTape)
                .pattern("SWS")
                .pattern("S S")
                .pattern("S S")
                .define('W', ItemTags.WOOL)
                .define('S', Items.STICK)
                .unlockedBy("has_wool", has(ItemTags.WOOL))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockPostBox)
                .pattern("XSX")
                .pattern("III")
                .pattern("XXX")
                .define('X', ItemTags.PLANKS)
                .define('I', Tags.Items.CHESTS)
                .define('S', buildTool.get())
                .unlockedBy("has_items", hasAllOf(
                        ItemPredicate.Builder.item().of(buildTool.get()).build(),
                        ItemPredicate.Builder.item().of(Tags.Items.CHESTS).build()))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockStash)
                .pattern("XSX")
                .pattern("IXI")
                .pattern("XXX")
                .define('X', ItemTags.PLANKS)
                .define('I', Tags.Items.CHESTS)
                .define('S', buildTool.get())
                .unlockedBy("has_items", hasAllOf(
                        ItemPredicate.Builder.item().of(buildTool.get()).build(),
                        ItemPredicate.Builder.item().of(Tags.Items.CHESTS).build()))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockRack)
                .pattern("XXX")
                .pattern("ISI")
                .pattern("XXX")
                .define('X', ItemTags.PLANKS)
                .define('I', Items.IRON_NUGGET)
                .define('S', buildTool.get())
                .unlockedBy("has_build_tool", has(buildTool.get()))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModBlocks.blockWayPoint, 16)
                .pattern("XXX")
                .pattern("XBX")
                .pattern("XXX")
                .define('X', ItemTags.PLANKS)
                .define('B', buildTool.get())
                .unlockedBy("has_build_tool", has(buildTool.get()))
                .save(consumer);

        ShapelessRecipeBuilder.shapeless(Items.LARGE_FERN)
                .requires(Items.FERN)
                .requires(Items.FERN)
                .unlockedBy("has_fern", has(Items.FERN))
                .save(consumer, new ResourceLocation(MOD_ID, "doublefern"));

        ShapelessRecipeBuilder.shapeless(Items.TALL_GRASS)
                .requires(Items.GRASS)
                .requires(Items.GRASS)
                .unlockedBy("has_grass", has(Items.GRASS))
                .save(consumer, new ResourceLocation(MOD_ID, "doublegrass"));
    }

    private void buildFood(@NotNull final Consumer<FinishedRecipe> consumer,
                           @NotNull final String method,
                           @NotNull final SimpleCookingSerializer<?> serializer,
                           final int cookingTime)
    {
        SimpleCookingRecipeBuilder.cooking(Ingredient.of(ModItems.breadDough),
                Items.BREAD, 0.35f, cookingTime, serializer)
                .unlockedBy("has_dough", has(ModItems.breadDough))
                .save(consumer, append(new ResourceLocation(MOD_ID, "baked_bread"), "_", method));

        SimpleCookingRecipeBuilder.cooking(Ingredient.of(ModItems.cakeBatter),
                Items.CAKE, 0.35f, cookingTime, serializer)
                .unlockedBy("has_dough", has(ModItems.cakeBatter))
                .save(consumer, append(new ResourceLocation(MOD_ID, "baked_cake"), "_", method));

        SimpleCookingRecipeBuilder.cooking(Ingredient.of(ModItems.cookieDough),
                Items.COOKIE, 0.0475f, cookingTime / 8, serializer)
                .unlockedBy("has_dough", has(ModItems.cookieDough))
                .save(consumer, append(new ResourceLocation(MOD_ID, "baked_cookies"), "_", method));

        SimpleCookingRecipeBuilder.cooking(Ingredient.of(ModItems.rawPumpkinPie),
                Items.PUMPKIN_PIE, 0.35f, cookingTime, serializer)
                .unlockedBy("has_dough", has(ModItems.rawPumpkinPie))
                .save(consumer, append(new ResourceLocation(MOD_ID, "baked_pumpkin_pie"), "_", method));
    }

    private void buildOtherItems(@NotNull final Consumer<FinishedRecipe> consumer)
    {
        ShapedRecipeBuilder.shaped(ModItems.flagBanner)
                .pattern(" W ")
                .pattern(" W ")
                .pattern(" B ")
                .define('W', ItemTags.WOOL)
                .define('B', buildTool.get())
                .unlockedBy("has_items", hasAllOf(
                        ItemPredicate.Builder.item().of(buildTool.get()).build(),
                        ItemPredicate.Builder.item().of(ItemTags.WOOL).build()))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModItems.bannerRallyGuards)
                .pattern("AAA")
                .pattern("BXB")
                .pattern("CCC")
                .define('A', Items.IRON_SWORD)
                .define('B', ModBlocks.blockHutGuardTower)
                .define('X', Items.YELLOW_BANNER)
                .define('C', Items.BOW)
                .unlockedBy("has_items", hasAllOf(buildTool.get(), ModBlocks.blockHutGuardTower))
                .save(consumer);

        ShapedRecipeBuilder.shaped(Items.CHAINMAIL_HELMET)
                .pattern("NNN")
                .pattern("NIN")
                .define('I', Items.IRON_INGOT)
                .define('N', Items.IRON_NUGGET)
                .unlockedBy("has_iron", has(Items.IRON_INGOT))
                .save(consumer, new ResourceLocation(MOD_ID, "chainmailhelmet"));

        ShapedRecipeBuilder.shaped(Items.CHAINMAIL_CHESTPLATE)
                .pattern("I I")
                .pattern("NNN")
                .pattern("NNN")
                .define('I', Items.IRON_INGOT)
                .define('N', Items.IRON_NUGGET)
                .unlockedBy("has_iron", has(Items.IRON_INGOT))
                .save(consumer, new ResourceLocation(MOD_ID, "chainmailchestplate"));

        ShapedRecipeBuilder.shaped(Items.CHAINMAIL_LEGGINGS)
                .pattern("III")
                .pattern("N N")
                .pattern("N N")
                .define('I', Items.IRON_INGOT)
                .define('N', Items.IRON_NUGGET)
                .unlockedBy("has_iron", has(Items.IRON_INGOT))
                .save(consumer, new ResourceLocation(MOD_ID, "chainmailleggings"));

        ShapedRecipeBuilder.shaped(Items.CHAINMAIL_BOOTS)
                .pattern("I I")
                .pattern("N N")
                .define('I', Items.IRON_INGOT)
                .define('N', Items.IRON_NUGGET)
                .unlockedBy("has_iron", has(Items.IRON_INGOT))
                .save(consumer, new ResourceLocation(MOD_ID, "chainmailboots"));

        ShapedRecipeBuilder.shaped(ModItems.clipboard)
                .pattern("XTX")
                .pattern("XPX")
                .pattern("XXX")
                .define('X', Items.STICK)
                .define('P', Items.LEATHER)
                .define('T', buildTool.get())
                .unlockedBy("has_build_tool", has(buildTool.get()))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModItems.resourceScroll)
                .pattern("XTX")
                .pattern("XPX")
                .pattern("XPX")
                .define('X', Items.STICK)
                .define('P', Items.LEATHER)
                .define('T', buildTool.get())
                .unlockedBy("has_build_tool", has(buildTool.get()))
                .save(consumer);

        ShapedRecipeBuilder.shaped(shapeTool.get())
                .pattern("  X")
                .pattern(" S ")
                .pattern("S  ")
                .define('X', Items.EMERALD)
                .define('S', Items.STICK)
                .unlockedBy("has_stick", has(Items.STICK))
                .save(consumer, new ResourceLocation(MOD_ID, "shapetool"));

        ShapedRecipeBuilder.shaped(ModItems.supplyCamp)
                .pattern("   ")
                .pattern("C C")
                .pattern("CCC")
                .define('C', Tags.Items.CHESTS)
                .unlockedBy("has_chest", has(Tags.Items.CHESTS))
                .save(consumer);

        ShapedRecipeBuilder.shaped(ModItems.supplyChest)
                .pattern("   ")
                .pattern("B B")
                .pattern("BBB")
                .define('B', ItemTags.BOATS)
                .unlockedBy("has_boat", has(ItemTags.BOATS))
                .save(consumer);

        SimpleCookingRecipeBuilder.smelting(Ingredient.of(ModItems.scimitar), Items.IRON_NUGGET, 0.1f, 200)
                .unlockedBy("has_scimitar", has(ModItems.scimitar))
                .save(consumer, new ResourceLocation(MOD_ID, "iron_nugget_from_iron_scimitar_smelting"));
        SimpleCookingRecipeBuilder.blasting(Ingredient.of(ModItems.scimitar), Items.IRON_NUGGET, 0.1f, 100)
                .unlockedBy("has_scimitar", has(ModItems.scimitar))
                .save(consumer, new ResourceLocation(MOD_ID, "iron_nugget_from_iron_scimitar_blasting"));
    }
}
